// 话题文章相关的API接口

// 模拟文章数据库
const mockArticles = [
  {
    id: 1,
    title: '人工智能在教育领域的应用研究',
    summary: '深入探讨AI技术如何改变传统教育模式，提升学习效率和个性化教学体验。',
    content: '人工智能技术正在深刻改变教育行业...',
    tags: ['人工智能', '教育', '技术应用'],
    publishDate: '2024-01-15'
  },
  {
    id: 2,
    title: '可持续发展与绿色技术的未来展望',
    summary: '分析绿色技术在推动可持续发展中的重要作用和未来发展趋势。',
    content: '随着环境问题日益严重，可持续发展成为全球共识...',
    tags: ['可持续发展', '绿色技术', '环境保护'],
    publishDate: '2024-01-10'
  },
  {
    id: 3,
    title: '数字化转型对企业竞争力的影响分析',
    summary: '研究数字化转型如何重塑企业运营模式，提升市场竞争力。',
    content: '数字化转型已成为企业发展的必然趋势...',
    tags: ['数字化转型', '企业竞争力', '商业模式'],
    publishDate: '2024-01-08'
  },
  {
    id: 4,
    title: '区块链技术在供应链管理中的应用',
    summary: '探讨区块链技术如何提升供应链的透明度和可追溯性。',
    content: '区块链技术为供应链管理带来了革命性的变化...',
    tags: ['区块链', '供应链', '技术应用'],
    publishDate: '2024-01-05'
  },
  {
    id: 5,
    title: '5G技术在智慧城市建设中的作用',
    summary: '分析5G技术如何推动智慧城市的建设和发展。',
    content: '5G技术的广泛应用为智慧城市建设提供了强大支撑...',
    tags: ['5G技术', '智慧城市', '基础设施建设'],
    publishDate: '2024-01-03'
  },
  {
    id: 6,
    title: '大数据分析在医疗健康领域的应用',
    summary: '研究大数据技术如何改善医疗诊断和治疗效果。',
    content: '大数据分析正在医疗健康领域发挥越来越重要的作用...',
    tags: ['大数据', '医疗健康', '数据分析'],
    publishDate: '2024-01-01'
  }
];

// 搜索文章API
export const searchArticles = async (keyword) => {
  if (!keyword || keyword.trim() === '') {
    return [];
  }
  
  try {
    const response = await fetch('/media/article/search/topic/article', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        keyword: keyword.trim()
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data || [];
  } catch (error) {
    console.error('搜索文章失败:', error);
    // 如果API调用失败，返回空数组
    return [];
  }
};

// 生成主题API
export const generateTopic = async (articles) => {
  if (!articles || articles.length === 0) {
    throw new Error('没有提供文章数据');
  }
  
  try {
    const articleList = articles.map(article => ({
      title: article.title || '自定义素材',
      content: article.content || article.summary || '',
      create_time: article.create_time || article.publishDate || new Date().toISOString()
    }));
    
    const response = await fetch('/media/article/create/topic/article', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        article_list: articleList
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('生成主题失败:', error);
    throw error;
  }
};

// 生成框架API
export const generateFramework = async (articles, topic) => {
  if (!articles || articles.length === 0) {
    throw new Error('没有提供文章数据');
  }
  
  if (!topic || topic.trim() === '') {
    throw new Error('没有提供主题数据');
  }
  
  try {
    const articleList = articles.map(article => ({
      title: article.title || '自定义素材',
      content: article.content || article.summary || '',
      create_time: article.create_time || article.publishDate || new Date().toISOString()
    }));
    
    const response = await fetch('/media/article/create/topic/article/framework', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        article_list: articleList,
        topic: topic.trim()
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('生成框架失败:', error);
    throw error;
  }
};

// 生成标题API
export const generateTitle = async (style, type, info) => {
  
  try {

    const response = await fetch('/media/predict/test/create/title/by/point/with/content', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        opinion_content: info,
        style: style,
        type: type
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('生成标题失败:', error);
    throw error;
  }
};

// 流式生成文章API
export const streamGenerateArticle = async (articles, topic, framework, num = 500, onChunk, isScript = false) => {
  if (!articles || articles.length === 0) {
    throw new Error('没有提供文章数据');
  }
  
  // if (!topic || topic.trim() === '') {
  //   throw new Error('没有提供主题数据');
  // }
  
  // if (!framework || framework.trim() === '') {
  //   throw new Error('没有提供框架数据');
  // }
  
  try {
    const articleList = articles.map(article => ({
      title: article.title || '自定义素材',
      content: article.content || article.summary || '',
      create_time: article.create_time || article.publishDate || new Date().toISOString()
    }));
    
    const response = await fetch('/media/article/create/topic/article/content', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        article_list: articleList,
        topic: topic.trim(),
        framework: framework.trim(),
        num: num,
        is_script: isScript ? 1 : 0
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const reader = response.body.getReader();
    const decoder = new TextDecoder('utf-8');
    let buffer = ''; // 用于处理跨chunk的数据
    let isStreamComplete = false; // 标记流是否完成
    
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      // 将新数据添加到缓冲区
      buffer += decoder.decode(value, { stream: true });
      
      // 按行分割，但保留最后一行（可能不完整）
      const lines = buffer.split('\n');
      buffer = lines.pop() || ''; // 保留最后一行
      
      for (const line of lines) {
        if (line.trim() === '') continue;
        
        // 查找data: 前缀
        if (line.startsWith('data: ')) {
          const jsonStr = line.substring(6);
          
          if (jsonStr === '[DONE]') {
            console.log('Stream completed');
            isStreamComplete = true;
            continue;
          }
          
          try {
            const data = JSON.parse(jsonStr);
            
            // 检查是否是完整内容（流结束时的完整数据）
            if (data.content && typeof data.content === 'string' && isStreamComplete) {
              // 这是流结束后的完整内容，替换而不是追加
              const processedContent = data.content
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;')
                .replace(/\n/g, '<br>')
                .replace(/\r/g, '');
              
              onChunk(processedContent, true); // 第二个参数表示这是完整内容
              console.log('Received complete content after stream, replaced');
            }
            // 处理token
            else if (data.token) {
              const token = data.token;
              const processedToken = token
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;')
                .replace(/\n/g, '<br>')
                .replace(/\r/g, '');
              
              onChunk(processedToken, false); // 第二个参数表示这是token
            }
          } catch (error) {
            console.error('JSON parse error:', jsonStr, error);
          }
        }
        // 如果不是SSE格式，尝试直接解析JSON
        else {
          try {
            const data = JSON.parse(line);
            
            // 检查是否是完整内容
            if (data.content && typeof data.content === 'string' && isStreamComplete) {
              const processedContent = data.content
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;')
                .replace(/\n/g, '<br>')
                .replace(/\r/g, '');
              
              onChunk(processedContent, true);
              console.log('Received complete content after stream, replaced');
            }
            // 处理token
            else if (data.token) {
              const token = data.token;
              const processedToken = token
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;')
                .replace(/\n/g, '<br>')
                .replace(/\r/g, '');
              
              onChunk(processedToken, false);
            }
          } catch (error) {
            // 不是JSON格式，忽略
          }
        }
      }
    }
    
    return { success: true };
  } catch (error) {
    console.error('生成文章失败:', error);
    throw error;
  }
};



// 获取历史记录API
export const getHistoryRecords = async (page = 1) => {
  try {
    const response = await fetch(`/media/article/search/topic/article/record`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        page: page,
        limit: 5
      })
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data || { records: [], total: 0, currentPage: page };
  } catch (error) {
    console.error('获取历史记录失败:', error);
    return { records: [], total: 0, currentPage: page };
  }
};

// 保存历史记录API
export const saveHistoryRecord = async (record) => {
  await new Promise(resolve => setTimeout(resolve, 100));
  
  const history = await getHistoryRecords();
  history.unshift({
    ...record,
    id: Date.now(),
    createdAt: new Date().toISOString()
  });
  
  // 限制历史记录数量
  if (history.length > 50) {
    history.splice(50);
  }
  
  localStorage.setItem('topicArticleHistory', JSON.stringify(history));
  return { success: true };
}; 